home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 343_02 / tiff.c < prev    next >
C/C++ Source or Header  |  1991-03-11  |  8KB  |  299 lines
  1.  
  2.  
  3.        /*******************************************************
  4.        *
  5.        *       file d:\cips\tiff.c
  6.        *
  7.        *       Functions: This file contains
  8.        *      read_tiff_header
  9.        *      extract_long_from_buffer
  10.        *      extract_short_from_buffer
  11.        *
  12.        *       Purpose:
  13.        *      This file contains the subroutines that read the
  14.        *      tiff files header information.
  15.        *
  16.        *       External Calls:
  17.        *      mof.c - my_open_file
  18.        *      mrw.c - my_read
  19.        *
  20.        *       Modifications:
  21.        *      23 June 1990 - created
  22.        *
  23.        *******************************************************/
  24.  
  25. #include "d:\cips\cips.h"
  26.  
  27.  
  28.  
  29.  
  30. read_tiff_header(file_name, image_header)
  31.    char file_name[];
  32.    struct tiff_header_struct *image_header;
  33. {
  34.    char buffer[12], response[80];
  35.  
  36.    int      bytes_read,
  37.       closed,
  38.       file_desc,
  39.       i,
  40.       j,
  41.       lsb,
  42.       not_finished;
  43.  
  44.    long bits_per_pixel,
  45.       image_length,
  46.       image_width,
  47.       length_of_field,
  48.       offset_to_ifd,
  49.       position,
  50.       strip_offset,
  51.       subfile,
  52.       value;
  53.  
  54.    short entry_count,
  55.        field_type,
  56.        s_bits_per_pixel,
  57.        s_image_length,
  58.        s_image_width,
  59.        s_strip_offset,
  60.        tag_type;
  61.  
  62.    /*file_desc = my_open(file_name);*/
  63.    file_desc = open(file_name, O_BINARY | O_RDONLY);
  64.    /*printf("\nTIFF.C> file desc = %d", file_desc);*/
  65.    if(file_desc > 0){
  66.  
  67.         /*************************************
  68.         *
  69.         *   Determine if the file uses MSB
  70.         *   first or LSB first
  71.         *
  72.         *************************************/
  73.  
  74.    bytes_read = my_read(file_desc, buffer, 8);
  75.  
  76.    if(buffer[0] == 0x49)
  77.       lsb = 1;
  78.    else
  79.       lsb = 0;
  80.  
  81.         /*************************************
  82.         *
  83.         *   Read the offset to the IFD
  84.         *
  85.         *************************************/
  86.  
  87.    extract_long_from_buffer(buffer, lsb, 4, &offset_to_ifd);
  88.  
  89.    not_finished = 1;
  90.    while(not_finished){
  91.  
  92.         /*************************************
  93.         *
  94.         *   Seek to the IFD and read the
  95.         *   entry_count, i.e. the number of
  96.         *   entries in the IFD.
  97.         *
  98.         *************************************/
  99.  
  100.       position = lseek(file_desc, offset_to_ifd, 0);
  101.       bytes_read = my_read(file_desc, buffer, 2);
  102.       extract_short_from_buffer(buffer, lsb, 0, &entry_count);
  103.  
  104.         /***************************************
  105.         *
  106.         *   Now loop over the directory entries.
  107.         *   Look only for the tags we need.  These
  108.         *   are:
  109.         *     ImageLength
  110.        *   ImageWidth
  111.         *     BitsPerPixel(BitsPerSample)
  112.         *     StripOffset
  113.         *
  114.         *****************************************/
  115.  
  116.       for(i=0; i<entry_count; i++){
  117.        bytes_read = my_read(file_desc, buffer, 12);
  118.        extract_short_from_buffer(buffer, lsb, 0, &tag_type);
  119.  
  120.        switch(tag_type){
  121.  
  122.           case 255: /* Subfile Type */
  123.              extract_short_from_buffer(buffer, lsb, 2, &field_type);
  124.              extract_short_from_buffer(buffer, lsb, 4,
  125. &length_of_field);
  126.              extract_long_from_buffer(buffer, lsb, 8, &subfile);
  127.              break;
  128.  
  129.           case 256: /* ImageWidth */
  130.              extract_short_from_buffer(buffer, lsb, 2, &field_type);
  131.              extract_short_from_buffer(buffer, lsb, 4,
  132. &length_of_field);
  133.              if(field_type == 3){
  134.               extract_short_from_buffer(buffer, lsb, 8,
  135. &s_image_width);
  136.               image_width = s_image_width;
  137.              }
  138.              else
  139.               extract_long_from_buffer(buffer, lsb, 8, &image_width);
  140.              break;
  141.  
  142.           case 257: /* ImageLength */
  143.              extract_short_from_buffer(buffer, lsb, 2, &field_type);
  144.              extract_short_from_buffer(buffer, lsb, 4,
  145. &length_of_field);
  146.              if(field_type == 3){
  147.               extract_short_from_buffer(buffer, lsb, 8,
  148. &s_image_length);
  149.               image_length = s_image_length;
  150.              }
  151.              else
  152.               extract_long_from_buffer(buffer, lsb, 8,
  153. &image_length);
  154.              break;
  155.  
  156.           case 258: /* BitsPerPixel */
  157.              extract_short_from_buffer(buffer, lsb, 2, &field_type);
  158.              extract_short_from_buffer(buffer, lsb, 4,
  159. &length_of_field);
  160.              if(field_type == 3){
  161.               extract_short_from_buffer(buffer, lsb, 8,
  162. &s_bits_per_pixel);
  163.               bits_per_pixel = s_bits_per_pixel;
  164.              }
  165.              else
  166.               extract_long_from_buffer(buffer, lsb, 8,
  167. &bits_per_pixel);
  168.              break;
  169.  
  170.           case 273: /* StripOffset */
  171.              extract_short_from_buffer(buffer, lsb, 2, &field_type);
  172.              extract_short_from_buffer(buffer, lsb, 4,
  173. &length_of_field);
  174.              if(field_type == 3){
  175.               extract_short_from_buffer(buffer, lsb, 8,
  176. &s_strip_offset);
  177.               strip_offset = s_strip_offset;
  178.              }
  179.              else
  180.               extract_long_from_buffer(buffer, lsb, 8,
  181. &strip_offset);
  182.              break;
  183.  
  184.           default:
  185.              break;
  186.  
  187.        }  /* ends switch tag_type */
  188.  
  189.       }  /* ends loop over i directory entries */
  190.  
  191.       bytes_read = my_read(file_desc, buffer, 4);
  192.       extract_long_from_buffer(buffer, lsb, 0, &offset_to_ifd);
  193.       if(offset_to_ifd == 0) not_finished = 0;
  194.  
  195.    }  /* ends while not_finished */
  196.  
  197.  
  198.    image_header->lsb                = lsb;
  199.    image_header->bits_per_pixel = bits_per_pixel;
  200.    image_header->image_length       = image_length;
  201.    image_header->image_width        = image_width;
  202.    image_header->strip_offset       = strip_offset;
  203.  
  204.    closed = close(file_desc);
  205.    }  /* ends if file opened ok */
  206.    else{
  207.       printf("\n\nTIFF.C> ERROR - could not open tiff file");
  208.    }
  209.  
  210.  
  211.  
  212. }  /* ends read_tiff_header */
  213.  
  214.  
  215.  
  216.  
  217.  
  218.    /****************************************
  219.    *
  220.    *   extract_long_from_buffer(...
  221.    *
  222.    *   This takes a four byte long out of a
  223.    *   buffer of characters.
  224.    *
  225.    *   It is important to know the byte order
  226.    *   LSB or MSB.
  227.    *
  228.    ****************************************/
  229.  
  230.  
  231. extract_long_from_buffer(buffer, lsb, start, number)
  232.    char  buffer[];
  233.    int       lsb, start;
  234.    long  *number;
  235. {
  236.    int i;
  237.    union long_char_union lcu;
  238.  
  239.    if(lsb == 1){
  240.       lcu.l_alpha[0] = buffer[start+0];
  241.       lcu.l_alpha[1] = buffer[start+1];
  242.       lcu.l_alpha[2] = buffer[start+2];
  243.       lcu.l_alpha[3] = buffer[start+3];
  244.    }  /* ends if lsb = 1 */
  245.  
  246.    if(lsb == 0){
  247.       lcu.l_alpha[0] = buffer[start+3];
  248.       lcu.l_alpha[1] = buffer[start+2];
  249.       lcu.l_alpha[2] = buffer[start+1];
  250.       lcu.l_alpha[3] = buffer[start+0];
  251.    }  /* ends if lsb = 0      */
  252.  
  253.    *number = lcu.l_num;
  254.  
  255.  
  256. }  /* ends extract_long_from_buffer */
  257.  
  258.  
  259.  
  260.  
  261.  
  262.    /****************************************
  263.    *
  264.    *   extract_short_from_buffer(...
  265.    *
  266.    *   This takes a two byte short out of a
  267.    *   buffer of characters.
  268.    *
  269.    *   It is important to know the byte order
  270.    *   LSB or MSB.
  271.    *
  272.    ****************************************/
  273.  
  274.  
  275.  
  276. extract_short_from_buffer(buffer, lsb, start, number)
  277.    char  buffer[];
  278.    int       lsb, start;
  279.    short *number;
  280. {
  281.  
  282.    int i;
  283.    union short_char_union lcu;
  284.  
  285.    if(lsb == 1){
  286.       lcu.s_alpha[0] = buffer[start+0];
  287.       lcu.s_alpha[1] = buffer[start+1];
  288.    }  /* ends if lsb = 1 */
  289.  
  290.    if(lsb == 0){
  291.       lcu.s_alpha[0] = buffer[start+1];
  292.       lcu.s_alpha[1] = buffer[start+0];
  293.    }  /* ends if lsb = 0      */
  294.  
  295.    *number = lcu.s_num;
  296.  
  297.  
  298. }  /* ends extract_short_from_buffer */
  299.